This section details on the original issue you should resolve

<issue_title>ENH: Drag curve as a function of Re and alpha as well</issue_title>
<issue_description>Is your feature request related to a problem? Please describe.

As of now drag curve is a function of speed (or mach number). Since a lot of rocketeers use CFD simulations, it is expected that drag values won't be just a function of mach number. Drag of any body moving in fluid can depend on many major parameters. Some of them are listed below:

• Reynolds Number (Re)
• Angle of Attack (alpha)
• Altitude/Air Properties
• Rocket Geometry/Shape
• Surface Roughness

Re accounts for the viscous effects of the flow (skin friction vs. pressure drag). Reynolds number depends on velocity, characteristic length, air viscosity, and density, and is crucial for modeling drag at low speeds and during laminar-turbulent transitions. Non-zero angles of attack change the effective cross-sectional area and cause flow separation or vortex formation, increasing drag. Altitude or atmospheric variation can be handled by RocketPy separately to update Re or atmospheric data rather than being built directly into the drag curve.
Drag could be input as Cd(M, α) or Cd(M, Re, α).

Describe the solution you'd like

1. A multidimensional array implementation of Cd=f(M,Re,α) in Rocket Class.
2. Extension of drag_coeff in flight class to allow multiple params as input - M, Re and alpha. Probably implement new get_value_opt like function specifically for this.
3. Check if current interpolation and extrapolation methods of the Function class are applicable in case of 2D/3D arrays. If not then update the same.
4. Ensure backwards compatibility to still allow for use of Cd=f(M).

Additional context

It does not make sense that the drag curve will be given as an input of Cd=f(Re) or Cd=f(α). Physically these are not capturing the entire flow physics at the same accuracy at which Cd=f(M) does as mach number based effects like shock wave propagation become more important in rocket flights. May be still allow for single array functionality with Re and α but provide a note that the results may not be accurate!</issue_description>

<agent_instructions>Here is a specific, technical prompt you can use to delegate this issue to the GitHub Copilot agent. This prompt directs it to the correct implementation strategy we discussed (enhancing the Function class).

Optional Prompt for GitHub Copilot

Here is a specific prompt to guide the implementation for Issue #874.

1. Core Objective:
Implement the enhancement described in issue #874. The goal is to allow the drag coefficient Cd to be defined as a 3D function of Mach (M), Reynolds number (Re), and Angle of Attack ($\alpha$).

2. Implementation Location:
The primary changes must be made within the rocketpy.Function class (in rocketpy/function.py). This is not just a change to the Flight or Rocket class; the Function class itself must be enhanced to handle N-dimensional structured grid data.

3. Add New Interpolation Method:
The current shepard interpolation is inefficient for structured CFD grids.

• Add a new interpolation option (e.g., interpolation='linear_grid' or interpolation='grid') to the Function class __init__.
• This new method MUST use scipy.interpolate.RegularGridInterpolator as its backend. You will need to import this from scipy.interpolate.
• The Function class state should store the initialized RegularGridInterpolator object to be called later.

4. Add New Function.from_grid() Class Method:
Manually creating a flattened list of points is impractical for users.

• Create a new class method: @classmethod def from_grid(cls, grid_data, axes, inputs, output, interpolation='linear_grid', **kwargs).
• This method will accept:
  • grid_data: An N-dimensional NumPy array (e.g., a 3D array for $C_d$).
  • axes: A list of 1D arrays representing the axes of the grid (e.g., [M_axis, Re_axis, A_axis]).
  • inputs: A list of strings, e.g., ['Mach', 'Reynolds', 'Alpha'].
  • output: A string, e.g., 'Cd'.
• Inside this method, you will initialize the scipy.interpolate.RegularGridInterpolator with the provided axes and grid_data and store it in the new Function object.

5. Handle Extrapolation (Crucial):
The new grid interpolation must clamp to the edge (i.e., use the nearest edge value) for out-of-bounds requests. It should not extrapolate.

• When initializing RegularGridInterpolator, set bounds_error=False.
• The fill_value should be set to None, which (when bounds_error=False) causes the interpolator to use the edge values for out-of-bounds points.

6. Update Flight Class:
The Flight class (likely in flight.py or related files) must be modified to use this new function.

• The flight simulation loop needs to detect the type of drag function it has.
• If the `rocket.aerodynamic_surfaces.dra...